package com.wyw.function.learning.demo5;

import com.wyw.function.learning.common.OrderClient;
import com.wyw.function.learning.common.Trader;
import com.wyw.function.learning.common.Transaction;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Title 使用流
 * @Description 流操作：无状态和有状态
 *                  诸如map或filter等操作会从输入流中获取每一个元素，并在输出流中得到0或1个结果。这些操作一般都是无状态的：他们没有内部状态（假设用户提供的Lambda或方法引用没有内部可变状态）
 *                  诸如reduce、sum、max等操作需要内部状态进行累积结果。不管流中有多少元素要处理，内部状态都是有界的
 *                  诸如sort或distinct等操作一开始都和filter和map差不多——都是接收一个流，在生成一个流（中间操作），但是有一个关键的区别，从流中排序和删除重复项时都需要知道先前的历史。
 * @Author Mr Wu yewen.wu.china@gmail.com
 * Update History:
 * Author        Time            Content
 */
public class DemoClient10 {

    // 找出2011年发生的所有交易，并按交易额排序（从低到高）
    // 降序使用Comparator 提供的reverseOrder() 方法
//    public static void main(String[] args) {
//        List<Transaction> transaction = OrderClient.getTransaction();
//        List<Transaction> collect =
//                transaction.stream()
//                        .filter(t1 -> t1.getYear() == 2011)
////                        .sorted(Comparator.comparing(Transaction::getValue))
////                        .sorted((o1, o2) -> o1.getValue() - o2.getValue())
//                        .sorted(Comparator.comparingInt(Transaction::getValue))
//                        .collect(Collectors.toList());
//        System.out.println(collect);
//
//    }

    // 交易员都在哪些不同的城市呆过
//    public static void main(String[] args) {
//        List<Transaction> transaction = OrderClient.getTransaction();
//
//        List<String> collect = transaction.stream()
//                .map(t1 -> t1.getTrader().getCity())
//                .distinct()
//                .collect(Collectors.toList());
//
//        System.out.println(collect);
//
//    }

    // 查找所有来自剑桥的交易员，并按照姓名排序
    public static void main(String[] args) {
        List<Transaction> transaction = OrderClient.getTransaction();

//        List<String> collect = transaction.stream()
//                .filter(t1 -> "Cambridge".equalsIgnoreCase(t1.getTrader().getCity()))
//                .map(t1 -> t1.getTrader().getName())
//                .sorted()
//                .distinct()
//                .collect(Collectors.toList());

        List<Trader> collect = transaction.stream()
                .map(Transaction::getTrader)
                .filter(t1 -> "Cambridge".equalsIgnoreCase(t1.getCity()))
                .distinct()
                .sorted(Comparator.comparing(Trader::getName))
                .collect(Collectors.toList());

        System.out.println(collect);
    }

    // 返回所有交易员姓名字符串，并按字母顺序排序
//    public static void main(String[] args) {
//        List<Transaction> transaction = OrderClient.getTransaction();
//
//        String reduce = transaction.stream()
//                .map(Transaction::getTrader)
//                .map(Trader::getName)
//                .distinct()
//                .sorted()
//                .reduce("", (a, b) -> a + b);
//
//        System.out.println(reduce);
//
//    }

    // 有没有在米兰工作的交易员
//    public static void main(String[] args) {
//        List<Transaction> transaction = OrderClient.getTransaction();
//
//        Optional<Transaction> first = transaction.stream()
//                .filter(t -> "Milan".equals(t.getTrader().getCity()))
//                .findFirst();
//
//        System.out.println(first.isPresent());
//
//    }

    // 打印生活在剑桥的交易员的总交易额
//    public static void main(String[] args) {
//        List<Transaction> transaction = OrderClient.getTransaction();
//
//        Optional<Integer> reduce = transaction.stream()
//                .filter(t1 -> "Cambridge".equalsIgnoreCase(t1.getTrader().getCity()))
//                .map(Transaction::getValue)
//                .reduce(Integer::sum);
//
//        System.out.println(reduce);
//
//    }

    //所有交易中，最高的交易额
//    public static void main(String[] args) {
//        List<Transaction> transaction = OrderClient.getTransaction();
//
//        Optional<Integer> reduce = transaction.stream()
//                .map(Transaction::getValue)
//                .reduce(Integer::max);
//
//        System.out.println(reduce);
//
//        Integer reduce = transaction.stream()
//                .map(Transaction::getValue)
//                .reduce(0, Integer::max);
//
//        System.out.println(reduce);
//
//    }

    //所有交易中，最小的交易额
//    public static void main(String[] args) {
//        List<Transaction> transaction = OrderClient.getTransaction();
//
//        Optional<Integer> reduce = transaction.stream()
//                .map(Transaction::getValue)
//                .reduce(Integer::min);
//
//        System.out.println(reduce);
//
//        Optional<Transaction> min = transaction.stream()
//                .min(Comparator.comparing(Transaction::getValue));
//
//        System.out.println(min);
//
//        Optional<Transaction> reduce1 = transaction.stream()
//                .reduce(((t1, t2) -> t1.getValue() < t2.getValue() ? t1 : t2));
//
//        System.out.println(reduce1);
//
//
//    }


}
